package com.lbz.service.Impl;

import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.lbz.common.Constant;
import com.lbz.common.ResponseCode;
import com.lbz.common.ServerResponse;
import com.lbz.dao.CartMapper;
import com.lbz.dao.ProductMapper;
import com.lbz.entity.Cart;
import com.lbz.entity.Product;
import com.lbz.service.CartService;
import com.lbz.utils.BigDecimalUtil;
import com.lbz.utils.PropertiesUtil;
import com.lbz.vo.CartProductVO;
import com.lbz.vo.CartVO;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.List;

/**
 * @Author 林必昭
 * @Date 2019/6/18 16:26
 */

@Service
public class CartServiceImpl  implements CartService {

    @Autowired
    private CartMapper cartMapper;

    @Autowired
    private ProductMapper productMapper;

    /**
     * 返回购物车list列表，将getCartVoLimit封装返回ServerResponse<CartVO>类型
     * @param userId
     * @return
     */
    @Override
    public ServerResponse<CartVO> list(Integer userId) {
        CartVO cartVO = this.getCartVoLimit(userId);
        return ServerResponse.createBySuccess(cartVO);
    }

    /**
     * 添加购物车
     * @param userId
     * @param productId
     * @param count
     * @return
     */
    @Override
    public ServerResponse<CartVO> addCart(Integer userId, Integer productId, Integer count) {
        //参数判空放在service层
        if (productId ==null || count ==null){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        Cart cart = cartMapper.selectCartByUserIdProductId(userId, productId);
        if (cart==null){
            //如果购物车为空，表明该商品没有在这个购物车中，需要新增一条记录
            Cart cartItem = new Cart();
            cartItem.setChecked(Constant.Cart.CHECKED);
            cartItem.setUserId(userId);
            cartItem.setProductId(productId);
            cartItem.setQuantity(count);
            cartMapper.insert(cartItem);
        }else {
            //该商品已经存在购物车，数量相加
            count = cart.getQuantity()+count;
            cart.setQuantity(count);
            cartMapper.updateByPrimaryKeySelective(cart);
        }

//        CartVO cartVO = this.getCartVoLimit(userId);
//        return ServerResponse.createBySuccess(cartVO);
        return this.list(userId);
    }

    /**
     * 封装了购物车的返回，解决当购买数量超过库存的问题，最后返回的是CartVO
     *
     * cartProductVO -> cartProductList -> cartVO
     * @param userId
     * @return
     */
    private CartVO getCartVoLimit(Integer userId){
        CartVO cartVO = new CartVO();
        List<Cart> cartList = cartMapper.selectCartByUserId(userId);
        List<CartProductVO> cartProductVOList = Lists.newArrayList();

        //定义整个购物车的最终总价格
        BigDecimal cartTotalPrice = new BigDecimal("0");
        if (CollectionUtils.isNotEmpty(cartList)){
            for (Cart cartItem : cartList){
                CartProductVO cartProductVO = new CartProductVO();
                cartProductVO.setId(cartItem.getId());
                cartProductVO.setUserId(userId);
                cartProductVO.setProductId(cartItem.getProductId());

                //接着查询购物车里面的产品对象
                Product product = productMapper.selectByPrimaryKey(cartItem.getProductId());
                if (product!=null){
                    cartProductVO.setProductName(product.getName());
                    cartProductVO.setProductMainImage(product.getMainImage());
                    cartProductVO.setProductSubtitle(product.getSubtitle());
                    cartProductVO.setProductStatus(product.getStatus());
                    cartProductVO.setProductPrice(product.getPrice());
                    cartProductVO.setProductStock(product.getStock());

                    //判断库存
                    int buyLimitCount = 0;
                    if (product.getStock()>=cartItem.getQuantity()){
                        /**当库存大于添加的购物车添加商品数量时(即库存充足)，此时的buyLimitCount为要买的数量*/
                        buyLimitCount = cartItem.getQuantity();
                        cartProductVO.setLimitQuantity(Constant.Cart.LIMIT_NUM_SUCCESS);
                    }else{
                        /**库存不足，此时buyLimitCount为库存数量*/
                        buyLimitCount = product.getStock();
                        cartProductVO.setLimitQuantity(Constant.Cart.LIMIT_NUM_FAIL);
                        //更新购物车有效库存，购物车最大数量为库存量
                        Cart cartForQuantity = new Cart();
                        cartForQuantity.setId(cartItem.getId());
                        cartForQuantity.setQuantity(buyLimitCount);
                        cartMapper.updateByPrimaryKeySelective(cartForQuantity);
                    }
                    cartProductVO.setQuantity(buyLimitCount);
                    //计算当前购物车总某一个产品的总价 = 单价*数量
                    cartProductVO.setProductTotalPrice(BigDecimalUtil.mul(product.getPrice().doubleValue(),cartProductVO.getQuantity()));
                    cartProductVO.setProductChecked(cartItem.getChecked());
                }
                if (cartItem.getChecked() == Constant.Cart.CHECKED){
                    //如果已经勾选，增加到整个购物车总价中
                    cartTotalPrice = BigDecimalUtil.add(cartTotalPrice.doubleValue(),cartProductVO.getProductTotalPrice().doubleValue());
                }
                cartProductVOList.add(cartProductVO);
            }
        }
        cartVO.setCartTotalPrice(cartTotalPrice);
        cartVO.setCartProductVOList(cartProductVOList);
        cartVO.setAllChecked(this.getAllCheckedStatus(userId));
        cartVO.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix"));

        return cartVO;
    }


    /**
     * 判断是购物车否是全选状态
     * @param userId
     * @return
     */
    public boolean getAllCheckedStatus(Integer userId){
        if (userId==null){
            return false;
        }
        //查询未勾选单的数量是否为0，如何是0该方法返回true，即全选
        return cartMapper.selectProductCheckedStatusByUserId(userId) == 0;   //未勾选的
    }

    /**
     * 更新购物车商品数量
     * @param userId
     * @param productId
     * @param count
     * @return
     */
    @Override
    public ServerResponse<CartVO> update(Integer userId, Integer productId, Integer count) {
        if (productId==null||count==null){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        Cart cart = cartMapper.selectCartByUserIdProductId(userId, productId);
        if (cart!=null) {
            cart.setQuantity(count);
        }
        cartMapper.updateByPrimaryKeySelective(cart);
        return this.list(userId);
    }

    /**
     * 删除商品，删除的话可以一次性删除多个，所以要获取到productList
     * @param userId
     * @param productIds
     * @return
     */
    @Override
    public ServerResponse<CartVO> deleteProduct(Integer userId, String productIds) {
//        String[] productList = productIds.split(",");
        //使用guava的Splitter.on()方法
        List<String> productList = Splitter.on(",").splitToList(productIds);
        if (CollectionUtils.isEmpty(productList)){
            return ServerResponse.createByErrorCodeMessage(ResponseCode.ILLEGAL_ARGUMENT.getCode(),ResponseCode.ILLEGAL_ARGUMENT.getDesc());
        }
        cartMapper.deleteByUserIdProductIds(userId, productList);
        return this.list(userId);
    }

    /**
     * 单选和反选
     * @param userId
     * @param productId
     * @param checked
     * @return
     */
    @Override
    public ServerResponse<CartVO> selectOrUnSelectProduct(Integer userId, Integer productId,Integer checked){
        cartMapper.checkedOrUnCheckedProduct(userId,productId,checked);
//        CartVO cartVO = this.getCartVoLimit(userId);
//        return ServerResponse.createBySuccess(cartVO);
        return list(userId);
    }

    /**
     * 全选和全反选
     * @param userId
     * @param checked
     * @return
     */
    @Override
    public ServerResponse<CartVO> selectOrUnSelectAll(Integer userId,Integer checked) {
        cartMapper.checkedAllOrUnCheckedAll(userId,checked);
        return list(userId);
    }

    /**
     * 获取购物车商品数量
     * @param userId
     * @return
     */
    @Override
    public ServerResponse<Integer> getCartProductCount(Integer userId) {
        if (userId==null){
            //如果未登录用户，结果是0
            return ServerResponse.createBySuccess(0);
        }
        return ServerResponse.createBySuccess(cartMapper.selectCartProductCountByUserId(userId));
    }
}
